home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Texteditors / AlphaSpell / MUISpell / Source / Hooks.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-27  |  15.9 KB  |  739 lines
  1. /***************************************************************************
  2. *                                                                                                    *
  3. *    MUISpell                                                                                    *
  4. *    Spellchecking without texteditor, requires AlphaSpell and MUI            *
  5. *    Copyright (C) 1996  Dirk Holtwick                                                    *
  6. *                                                                                                    *
  7. *    This program is free software; you can redistribute it and/or modify    *
  8. *    it under the terms of the GNU General Public License as published by    *
  9. *    the Free Software Foundation; either version 2 of the License, or        *
  10. *    (at your option) any later version.                                                *
  11. *                                                                                                    *
  12. *    This program is distributed in the hope that it will be useful,            *
  13. *    but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  14. *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
  15. *    GNU General Public License for more details.                                    *
  16. *                                                                                                    *
  17. *    You should have received a copy of the GNU General Public License        *
  18. *    along with this program; if not, write to the Free Software                *
  19. *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                    *
  20. *                                                                                                    *
  21. *      Author:   Dirk Holtwick                                                                *
  22. *                    Karlstr. 59                                                                    *
  23. *                    47119 Duisburg                                                                *
  24. *                    GERMANY                                                                        *
  25. *                    dirco@uni-duisburg.de                                                    *
  26. *                                                                                                    *
  27. ****************************************************************************/
  28.  
  29. #define WLEN 256
  30. #define TEXT(a) ((char*)&(a->str))
  31. #define SUCC(a) a=a->succ;
  32.  
  33. BOOL    istext=FALSE,
  34.         learned=FALSE,
  35.         changed=FALSE;
  36.  
  37. struct StrData {
  38.     struct  StrData *succ;
  39.     char      str;
  40. }     *ebase=0, *elast=0,
  41.     *lbase=0, *llast=0;
  42.  
  43. BOOL    ramspell=FALSE,
  44.         ramdict=FALSE;
  45. char    *text,                // Der Originaltext
  46.         *textact,            // Aktuelle Position im Text
  47.         *textend,            // Ende des Textes
  48.         *textmax,            // Maximale Ausdehnung des Textes
  49.         *wordstart,            // Beginn des gefundenen Wortes
  50.         *view,                // Der ViewPuffer
  51.         textname[80],        // Name des Textes
  52.         command[400],        // Befehlsstring fuer Execute()
  53.         wort[WLEN],            // Einzelnes Wort (Hilfsvariable)
  54.         pathspell[10],        // Pfad zu AlphaSpell
  55.         pathdict[256];        // Pfad zu Wörterbüchern
  56.  
  57.  
  58. // ZURECHTGESCHNITTENE Execute() FUNKTION
  59. void Ex(char *s){
  60.     if(!Execute(s,0,0) /*|| IoErr()*/) MUI_RequestA (App->App,App->win_view,0,NULL,"*_Okay",GetMUISpellString(m_req_aerr),0);
  61. }
  62.  
  63. // COPY
  64. void RAM(){
  65.     ULONG    r;
  66.     long    l;
  67.     char    *path, *dict, buf[256], *b,*u;
  68.  
  69.     get (App->cy_ram, MUIA_Cycle_Active, &r);
  70.     get (App->str_drawer, MUIA_String_Contents, &path);
  71.     get (App->str_books, MUIA_String_Contents, &dict);
  72.     get (App->str_user, MUIA_String_Contents, &u);
  73.  
  74.     if((r==1)||(r==3)){
  75.         strcpy(pathspell,"ram:");
  76.         if(!ramspell){
  77.             Ex("c:copy c:alphaspell ram: >nil:");
  78.             ramspell=TRUE;
  79.         }
  80.     }else strcpy(pathspell,"c:");
  81.     if((r==1)||(r==2)){
  82.         strcpy(pathdict,"ram:");
  83.         if(!ramdict){
  84.             while(TRUE){
  85.                 while(*dict==' ') dict++;
  86.                 b=buf;
  87.                 while(*dict && (*dict!=' ')) *b++=*dict++;
  88.                 *b=0;
  89.                 if(buf[0]){ 
  90.                     sprintf(command,"c:copy \"%s%s\" to ram: >nil:",path,&buf);
  91.                     Ex(command);
  92.                     if(!strcmp(buf+strlen(buf)-4,".mix")){
  93.                         buf[strlen(buf)-4]=0;
  94.                         strcat(buf,".mdx");
  95.                         sprintf(command,"c:copy \"%s%s\" to ram: >nil:",path,&buf);
  96.                         Ex(command);
  97.                     }else if(!strcmp(buf+strlen(buf)-4,".low")){
  98.                         buf[strlen(buf)-4]=0;
  99.                         strcat(buf,".ldx");
  100.                         sprintf(command,"c:copy \"%s%s\" to ram: >nil:",path,&buf);
  101.                         Ex(command);
  102.                     }
  103.                 }else break;
  104.             }
  105.             ramdict=TRUE;
  106.             sprintf(command,"ram:%s.low",u);
  107.             if(l=Lock(command,ACCESS_READ)){
  108.                 UnLock(l);
  109.             }else{
  110.                 sprintf(command,"c:copy \"%s%s.mix\" \"%s%s.low\" \"%s%s.ldx\" \"%s%s.mdx\" to ram:",path,u,path,u,path,u,path,u);
  111.                 Ex(command);
  112.             }
  113.         }
  114.     }else strcpy(pathdict,path);
  115. }
  116.  
  117. BOOL chok (){
  118.     if(changed){
  119.         return(!MUI_RequestA (App->App,App->win_view,0,NULL,
  120.             GetMUISpellString(m_reqbt_notsaved),
  121.             GetMUISpellString(m_req_notsaved),0
  122.         ));
  123.     }
  124.     return(1);
  125. }
  126.  
  127. // WORT ODER ZEILE DARSTELLEN
  128. BOOL isword(){
  129.     long    l;
  130.  
  131.     get (App->cy_line, MUIA_Cycle_Active, &l);
  132.     return(!l);
  133. }
  134.  
  135. // ERRORLISTE LOESCHEN
  136. void freeerror(){
  137.     struct StrData *act, *nact;
  138.  
  139.     act=ebase;
  140.     while(act){
  141.         nact=act->succ;
  142.         free(act);
  143.         act=nact;
  144.     }
  145.     ebase=elast=0;
  146. }
  147.  
  148. // VORSCHLAGLISTE LOESCHEN
  149. void freelist(){
  150.     struct StrData *act, *nact;
  151.  
  152.     act=lbase;
  153.     while(act){
  154.         nact=act->succ;
  155.         free(act);
  156.         act=nact;
  157.     }
  158.     lbase=llast=0;
  159. }
  160.  
  161. // SCHLAFEN
  162. void sleep(BOOL b){
  163.     set (App->App, MUIA_Application_Sleep, b);
  164. }
  165.  
  166. // EIN WORT AUS DER FEHLERLISTE EINLESEN
  167. char *getword (FILE *f){
  168.     char    *w, c;
  169.  
  170.     w=wort;
  171.     while(!feof(f) && ((c=fgetc(f))!='\n')) *w++=c;
  172.     *w=0;
  173.     if(feof(f)) return(0);
  174.     return(wort);
  175. }
  176.  
  177. // AUSGEWAEHLTEN STRING AKZEPTIEREN
  178. void do_chstr(){
  179.     long    l;
  180.     char    *s;
  181.  
  182.     get (App->lv_spell, MUIA_List_Active, &l);
  183.     DoMethod (App->lv_spell, MUIM_List_GetEntry, l, &s);
  184.     set (App->str_spell, MUIA_String_Contents, s);
  185. }
  186.  
  187. // BEREITE VIEWFENSTER AUF
  188. void showpart(){
  189.     ULONG    a,b;
  190.     char    *t1,*t2;
  191.  
  192.     // Viewpuffer schaffen
  193.     get (App->sl_forward, MUIA_Slider_Level, &b);
  194.     get (App->sl_back, MUIA_Slider_Level, &a);
  195.  
  196.     a++; b++;
  197.  
  198.     t1=wordstart;
  199.     while((t1>=text) && (a>0)){
  200.         if(*t1=='\n') --a;
  201.         t1--;
  202.     }
  203.     t1++;
  204.     if(*t1=='\n') t1++;
  205.  
  206.     t2=textact;
  207.     while((*t2) && (b>0)){
  208.         if(*t2=='\n') --b;
  209.         t2++;
  210.     }
  211.  
  212.     if(view=malloc(t2-t1+100)){
  213.  
  214.         // Inhalt aufbauen
  215.         strncpy(view, t1, wordstart-t1);
  216.         strcat (view,"\0338\033b");
  217.         strcat (view,wort);
  218.         strcat (view,"\0330\033n");
  219.         strncat (view, textact, t2-textact);
  220.  
  221.         set (App->lv_view, MUIA_Floattext_Text, view);
  222.         set (App->txt_view, MUIA_Text_Contents, wort);
  223.         set (App->gauge_txt, MUIA_Gauge_Current, wordstart-text);
  224.  
  225.  
  226.         // Listerinhalt löschen
  227.         DoMethod (App->lv_spell, MUIM_List_Clear, 0);
  228.         freelist();
  229.  
  230.         set (App->str_spell, MUIA_String_Contents, wort);
  231.  
  232.         free(view);
  233.         view=0;
  234.     }else  MUI_RequestA (App->App,App->win_view,0,NULL,"*_Okay",GetMUISpellString(m_req_nomem),0);
  235.     set (App->win_view, MUIA_Window_ActiveObject, App->str_spell);
  236. }
  237.  
  238. // ZEILENENDE und ANFANG suchen
  239. void findline(){
  240.     char    *s,*w;
  241.  
  242.     do{
  243.         wordstart--;
  244.     }while((text<=wordstart) && (*wordstart!='\n'));
  245.     wordstart++;
  246.     while((*textact) && (*textact!='\n')) textact++;
  247.  
  248.     w=wort;
  249. //    textact--;
  250.     s=wordstart;
  251.     while(s<textact) *w++=*s++;
  252.     *w=0;
  253.  
  254.     if(*textact) istext=TRUE;
  255.     else istext=FALSE;
  256.     showpart();
  257. }
  258.  
  259. // WORT AN LOESUNGSLISTE ANHAENGEN
  260. void addlist (char *s){
  261.     struct StrData *act;
  262.  
  263.     if(act=malloc(strlen(s)+sizeof(struct StrData))){
  264.         if(lbase) llast->succ=act;
  265.         else lbase=act;
  266.         llast=act;
  267.         act->succ=0;
  268.         strcpy(TEXT(act),s);
  269.  
  270.         // Wort in die Listview-Liste einfuegen
  271.         DoMethod(App->lv_spell, MUIM_List_InsertSingle, TEXT(act), MUIV_List_Insert_Bottom);
  272.  
  273.     }else MUI_RequestA (App->App,App->win_view,0,NULL,"*_Okay",GetMUISpellString(m_req_nomem),0);
  274. }
  275.  
  276. // WOERTER IM TEXT SUCHEN
  277. char *findword(){
  278.     char    *w;
  279.  
  280.     while(*textact && !isalpha(*textact)) textact++;
  281.     w=wort;
  282.     wordstart=textact;
  283.     while(*textact && isalpha(*textact)) *w++=*textact++;
  284.     *w=0;
  285.     if(wort[0]) return(wort);
  286.     else return(0);    
  287. }
  288.  
  289. // WOERTER MIT FEHLERN VERGLEICHEN
  290. char *finderrword(){
  291.     struct    StrData    *act;
  292.  
  293.     while(findword()){
  294.         act=ebase;
  295.         while(act){
  296.             if(!strcmp(TEXT(act),wort)) return(wort);
  297.             SUCC(act);
  298.         }
  299.     }
  300.     return(0);
  301. }
  302.  
  303.  
  304. // WOERTER IM TEXT SUCHEN
  305. char *findbackword(){
  306.     char    *w;
  307.  
  308.     textact=wordstart;
  309.     do{
  310.         textact--;
  311.     }while((text<textact) && !isalpha(*textact));
  312.     if(text<textact){
  313.         do{
  314.             textact--;
  315.         }while((text<wordstart) && isalpha(*textact));
  316.  
  317.         w=wort;
  318.         wordstart=++textact;
  319.         while(*textact && isalpha(*textact)) *w++=*textact++;
  320.         *w=0;
  321.         if(wort[0]) return(wort);
  322.     }else{
  323.         textact=wordstart=text;
  324.         wort[0]=0;
  325.     }
  326.     return(0);
  327. }
  328.  
  329. // WOERTER MIT FEHLERN VERGLEICHEN
  330. char *findbackerrword(){
  331.     struct    StrData    *act;
  332.  
  333.     while(findbackword()){
  334.         act=ebase;
  335.         while(act){
  336.             if(!strcmp(TEXT(act),wort)) return(wort);
  337.             SUCC(act);
  338.         }
  339.     }
  340.     return(0);
  341. }
  342.  
  343. // RUECKWAERTS SPRINGEN
  344. void do_back(){
  345.  
  346.     DoMethod (App->pa_spell, MUIM_Popstring_Close);
  347.     sleep(TRUE);
  348.     if(isword()){
  349.         istext=(BOOL)findbackerrword();
  350.         showpart();
  351.     }else{
  352.         textact=--wordstart;
  353.         if(textact<text) textact=wordstart=text;
  354.         findline();
  355.     }
  356.     sleep(FALSE);
  357. }
  358.  
  359. // FEHLERHAFTE WOERTER SUCHEN
  360. void do_goon(){
  361.  
  362.     DoMethod (App->pa_spell, MUIM_Popstring_Close);
  363.     sleep (TRUE);
  364.     if(isword()){
  365.         istext=(BOOL)finderrword();
  366.         showpart();
  367.     }else{
  368.         if(*textact!=0){
  369.             wordstart=++textact;
  370.             findline();
  371.         }
  372.     }
  373.     sleep(FALSE);
  374. }
  375.  
  376.  
  377. // WORT AN ERRORLISTE ANHAENGEN
  378. void adderror (char *s){
  379.     struct StrData *act;
  380.  
  381.     if(act=malloc(strlen(s)+sizeof(struct StrData))){
  382.         if(ebase) elast->succ=act;
  383.         else ebase=act;
  384.         elast=act;
  385.         act->succ=0;
  386.         strcpy(TEXT(act),s);
  387.     }else MUI_RequestA (App->App,App->win_view,0,NULL,"*_Okay",GetMUISpellString(m_req_nomem),0);
  388. }
  389.  
  390.  
  391. // SPEICHER WIEDER FREIGEBEN
  392. void freeall(){
  393.     freeerror();
  394.     freelist();
  395.     if(view) free(view);
  396. }
  397.  
  398.  
  399. // DATEIGROESSE
  400. long lgetsize(char *fname){
  401.     long        size=0,locksave;
  402.     struct     FileInfoBlock  *fileinfo;
  403.  
  404.     // FileInfoBlock einlesen
  405.     fileinfo=malloc(sizeof(struct FileInfoBlock));
  406.     if (locksave=Lock(fname,ACCESS_READ)){
  407.         if(Examine(locksave,fileinfo)) size=fileinfo->fib_Size;
  408.         UnLock(locksave);
  409.     }else return(0);
  410.     free(fileinfo);
  411.     return(size);
  412. }
  413.  
  414.  
  415. // TEXT LADEN UND ANALYSIEREN
  416. void do_load(){
  417.     FILE        *f;
  418.     ULONG        size, percent;
  419.     char        *b;
  420.  
  421.     if(chok()){
  422.  
  423.     if (MUI_AslRequest (fr, 0)){
  424.  
  425.         strcpy (textname, fr->fr_Drawer);
  426.         AddPart(textname, fr->fr_File, 80);
  427.  
  428.         // Besser schlafen
  429.         sleep(TRUE);
  430.     
  431.         // Dateigroesse
  432.         if(size=lgetsize(textname)){
  433.         
  434.             // Fehler suchen
  435.             set (App->gauge_txt,     MUIA_Gauge_Max,           size);
  436. //            get (App->str_drawer, MUIA_String_Contents, &d);
  437.             get (App->str_books,  MUIA_String_Contents, &b);
  438. //            get (App->str_user,   MUIA_String_Contents, &u);
  439.  
  440.             RAM();
  441.  
  442.             sprintf (command,"%salphaspell -Ss \"%s\" -o t:text.cor -d \"%s\" %s",pathspell,textname,pathdict,b);
  443.             Ex (command);
  444.         
  445.             // Fehlerliste einlesen
  446.             freeerror();
  447.             if(f=fopen("t:text.cor","r")){
  448.                 while(getword(f)) adderror(wort);
  449.                 istext=TRUE;
  450.                 changed=FALSE;
  451.                 fclose(f);
  452.             }else  MUI_RequestA (App->App,App->win_view,0,NULL,"*_Okay",GetMUISpellString(m_req_fileerr),0);
  453.         
  454.             // TEXT EINLESEN
  455.         
  456.             // Puffer schaffen (+ Korrekturspielraum)
  457.             get (App->sl_buffer, MUIA_Slider_Level, &percent);
  458.             if(text=malloc(size+((percent*size)/100))){
  459.                 textend=text+size;
  460.                 textmax=textend+((percent*size)/100);
  461.  
  462.                 // Laden
  463.                 if (f=fopen(textname,"rb")){
  464.                     fread(text,size,1,f);
  465.                     fclose(f);
  466.                 }else MUI_RequestA (App->App,App->win_view,0,NULL,"*_Okay",GetMUISpellString(m_req_fileerr),0);
  467.         
  468.                 *textend=0;
  469.                 textact=text;
  470.             }else MUI_RequestA (App->App,App->win_view,0,NULL,"*_Okay",GetMUISpellString(m_req_nomem),0);
  471.         
  472.             // Suche ersten Fehler
  473.             do_goon();
  474.  
  475.         }else  MUI_RequestA (App->App,App->win_view,0,NULL,"*_Okay",GetMUISpellString(m_req_fileerr),0);
  476.         
  477.         // Jetzt kann's weiter gehen
  478.         sleep(FALSE);
  479.     }
  480.     }
  481. }
  482.  
  483. void do_save(){
  484.     FILE *f;
  485.  
  486.     sleep(TRUE);
  487.     if(f=fopen(textname,"wb")){
  488.         fwrite(text, textend-text, 1, f);
  489.         changed=FALSE;
  490.         fclose(f);
  491.     }
  492.     sleep(FALSE);
  493. }
  494.  
  495. void do_saveas(){
  496.     if (MUI_AslRequest (fr, 0)){
  497.         strcpy (textname, fr->fr_Drawer);
  498.         AddPart(textname, fr->fr_File, 80);
  499.         do_save();
  500.     }
  501. }
  502.  
  503. void do_guess(){
  504.     char    *w,*b,oldwort[WLEN];
  505.     long    r;
  506.     FILE    *f;
  507.  
  508.     sleep(TRUE);
  509.     strcpy(oldwort,wort);
  510.  
  511.     // Lister mit Loesungen fuellen
  512.     DoMethod (App->lv_spell, MUIM_List_Clear, 0);
  513.     freelist();
  514.     get (App->str_spell, MUIA_String_Contents, &w);
  515.  
  516.     // Vorschlaege sammeln
  517. //    get (App->str_drawer, MUIA_String_Contents, &d);
  518.     get (App->str_books,  MUIA_String_Contents, &b);
  519. //    get (App->str_user,   MUIA_String_Contents, &u);
  520.     get (App->sl_rate,    MUIA_Slider_Level, &r);
  521.  
  522.     RAM();
  523.  
  524.     sprintf (command,"%salphaspell >nil: -Gw \"%s\" -n %ld -o t:text.sug -d \"%s\" %s",pathspell,w,r,pathdict,b);
  525.     Ex(command);
  526.  
  527.     // Vorschläge lesen
  528.     if(f=fopen("t:text.sug","r")){
  529.         while(getword(f)) addlist(wort);
  530.         fclose(f);
  531.     }else MUI_RequestA (App->App,App->win_view,0,NULL,"*_Okay",GetMUISpellString(m_req_fileerr),0);
  532.  
  533.     strcpy(wort,oldwort);
  534.     sleep(FALSE);
  535.  
  536.     DoMethod (App->pa_spell, MUIM_Popstring_Open);
  537. }
  538.  
  539. ULONG do_popup(register __a1 Object *win){
  540.     set (win, MUIA_Window_DefaultObject, App->lv_spell);;
  541.     set (App->lv_spell, MUIA_List_Active, 0);
  542.     return(TRUE);
  543. }
  544.  
  545. void do_accept(){
  546.     char    *s,*ws;
  547.     BOOL  doit=TRUE;
  548.     int    l=0;
  549.  
  550.     DoMethod (App->pa_spell, MUIM_Popstring_Close);
  551.     sleep(TRUE);
  552.  
  553.     // Wort aendern
  554.     get (App->str_spell, MUIA_String_Contents, &s);
  555.  
  556.     if(istext){
  557.         // Platz schaffen
  558.         if(strlen(s)!=strlen(wort)){
  559.             l=strlen(s)-strlen(wort);
  560.             if(textmax<(textend+l)){
  561.                 MUI_RequestA (App->App,App->win_view,0,NULL,"*_Okay",GetMUISpellString(m_req_nospace),0);
  562.                 doit=FALSE;
  563.             }else{
  564.                 memcpy(textact+l,textact, textend-textact+1);
  565.                 textact+=l;
  566.                 textend+=l;
  567.             }
  568.         }
  569.  
  570.         strcpy(wort,s);
  571.         // Wort einsetzen
  572.         ws=wordstart;
  573.         if(doit) while(*s) *ws++=*s++;
  574.         textact=ws;
  575.         changed=TRUE;
  576.         showpart();
  577.     }
  578.  
  579.     // Naechstes Wort
  580. //    do_goon();
  581.  
  582.     sleep(FALSE);
  583. }
  584.  
  585. void do_lvaccept(){
  586.     long    l;
  587.     char    *s;
  588.  
  589.     get (App->lv_spell, MUIA_List_Active, &l);
  590.     DoMethod (App->lv_spell, MUIM_List_GetEntry, l, &s);
  591.     set (App->str_spell, MUIA_String_Contents, s);
  592.     do_accept();
  593. }
  594.  
  595. // USE
  596. void do_use_prefs(){
  597.     DoMethod(App->App,MUIM_Application_Save,MUIV_Application_Save_ENV);
  598.     set(App->win_prefs, MUIA_Window_Open, FALSE);
  599. }
  600.  
  601. // SAVE
  602. void do_save_prefs(){
  603.     DoMethod(App->App,MUIM_Application_Save,MUIV_Application_Save_ENV);
  604.     DoMethod(App->App,MUIM_Application_Save,MUIV_Application_Save_ENVARC);
  605.     set(App->win_prefs, MUIA_Window_Open, FALSE);
  606. }
  607.  
  608. //CANCEL
  609. void do_cancel_prefs(){
  610.     DoMethod(App->App,MUIM_Application_Load,MUIV_Application_Load_ENV);
  611.     set(App->win_prefs, MUIA_Window_Open, FALSE);
  612. }
  613.  
  614. // IGNORIEREN
  615. void do_ignore(){
  616.     char    *w,r=TRUE;
  617.     struct StrData *act,*lact;
  618.  
  619.     sleep(TRUE);
  620.     get (App->str_spell, MUIA_String_Contents, &w);
  621.  
  622.     // Wort aus der Liste löschen
  623.     act=ebase;
  624.     while(act && r){
  625.         if(!strcmp(TEXT(act),w)){
  626.             if(act==ebase) ebase=act->succ;
  627.             else lact->succ=act->succ;
  628.             free(act);
  629.             r=FALSE;
  630.         }
  631.         lact=act;
  632.         SUCC(act);    
  633.     }
  634.  
  635.    do_goon();
  636.  
  637.     sleep(FALSE);
  638. }
  639.  
  640. // EDIT DISTANCE
  641. void do_editdist(){
  642.     char    *s;
  643.  
  644.     // Slider auf die angemessene Groesse bringen
  645.     get (App->str_keyfile, MUIA_String_Contents, &s);
  646.     if(*s) set (App->sl_rate, MUIA_Slider_Max, 20);
  647.     else set (App->sl_rate, MUIA_Slider_Max, 2);
  648. }
  649.  
  650. // PREFERNCES
  651. void do_books(register __a1 struct FileRequester *fr){
  652.     struct WBArg *ap;
  653.     static char buf[256];
  654.     int    i;
  655.  
  656.     strcpy (buf,fr->fr_Drawer);
  657.     AddPart (buf, "", 255);
  658.     set (App->str_drawer, MUIA_String_Contents, buf);
  659.     buf[0]=0;
  660.     for (ap=fr->fr_ArgList,i=0;i<fr->fr_NumArgs;i++,ap++){
  661.         strcat(buf,ap->wa_Name);
  662.         strcat(buf," ");
  663.     }
  664.     set (App->str_books, MUIA_String_Contents, &buf);
  665. }
  666.  
  667. // PREFERNCES
  668. void do_bookstart(register __a1 ULONG *tlist){
  669.     char    *d;
  670.  
  671.     get (App->str_drawer, MUIA_String_Contents, &d);
  672.     *tlist++ = ASLFR_InitialDrawer;
  673.     *tlist++ = (ULONG)d;
  674.     *tlist++ = 0;
  675.     *tlist++ = 0;
  676. }
  677.  
  678. void do_drawer(){
  679.     char    *d, buf[256];
  680.  
  681.     get (App->str_drawer, MUIA_String_Contents, &d);
  682.     strcpy (buf,d);
  683.     AddPart (buf, "", 255);
  684.     set (App->str_drawer, MUIA_String_Contents, &buf);
  685. }
  686.  
  687. // WORT LERNEN
  688. void do_learn(){
  689.     char    *w,*ww,*u,*k,suf[4];
  690.     ULONG    l;
  691.  
  692.     sleep(TRUE);
  693.  
  694.     get (App->str_spell,   MUIA_String_Contents, &w);
  695.     get (App->str_user,    MUIA_String_Contents, &u);
  696. //    get (App->str_drawer,  MUIA_String_Contents, &d);
  697.     get (App->str_keyfile, MUIA_String_Contents, &k);
  698.  
  699.     ww=w;
  700.     strcpy(suf,"low");
  701.     while(*ww){
  702.         if(isupper(*ww)) strcpy(suf,"mix");
  703.         ww++;
  704.     }
  705.  
  706.     RAM();
  707.  
  708.     sprintf(command,"%s%s.%s",pathdict,u,suf);
  709.     if(l=Lock(command,ACCESS_READ)){
  710.         if(*k) sprintf(command,"%salphaspell >nil: -cLw \"%s\" -k \"%s\" -o \"%s%s.%s\" \"%s%s.%s\"",pathspell,w,k,pathdict,u,suf,pathdict,u,suf);
  711.         else sprintf(command,"%salphaspell >nil: -cLw \"%s\" -o \"%s%s.%s\" \"%s%s.%s\"",pathspell,w,pathdict,u,suf,pathdict,u,suf);
  712.         UnLock(l);
  713.     }else{
  714.         if(*k) sprintf(command,"%salphaspell >nil: -cLw \"%s\" -k \"%s\" -o \"%s%s.%s\"",pathspell,w,k,pathdict,u,suf);
  715.         else sprintf(command,"%salphaspell >nil: -cLw \"%s\" -o \"%s%s.%s\"",pathspell,w,pathdict,u,suf);
  716.     }
  717.     Ex(command);
  718.  
  719.     learned=TRUE;
  720.     do_ignore();
  721.  
  722.     sleep(FALSE); 
  723. }
  724.  
  725.  
  726. // GANZE ZEILE DARSTELLEN
  727. void do_line(){
  728.  
  729.     sleep(TRUE);
  730.     if(isword()){
  731.         textact=wordstart;
  732.         do_goon();
  733.     }else{
  734.         findline();
  735.     }
  736.     sleep(FALSE);
  737. }
  738.  
  739.